home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / device.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  18.5 KB  |  590 lines
  1. /*
  2.  * device.h - generic, centralized driver model
  3.  *
  4.  * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
  5.  * Copyright (c) 2004-2007 Greg Kroah-Hartman <gregkh@suse.de>
  6.  *
  7.  * This file is released under the GPLv2
  8.  *
  9.  * See Documentation/driver-model/ for more information.
  10.  */
  11.  
  12. #ifndef _DEVICE_H_
  13. #define _DEVICE_H_
  14.  
  15. #include <linux/ioport.h>
  16. #include <linux/kobject.h>
  17. #include <linux/klist.h>
  18. #include <linux/list.h>
  19. #include <linux/lockdep.h>
  20. #include <linux/compiler.h>
  21. #include <linux/types.h>
  22. #include <linux/module.h>
  23. #include <linux/pm.h>
  24. #include <linux/semaphore.h>
  25. #include <asm/atomic.h>
  26. #include <asm/device.h>
  27.  
  28. #define BUS_ID_SIZE        20
  29.  
  30. struct device;
  31. struct device_driver;
  32. struct driver_private;
  33. struct class;
  34. struct class_private;
  35. struct bus_type;
  36. struct bus_type_private;
  37.  
  38. struct bus_attribute {
  39.     struct attribute    attr;
  40.     ssize_t (*show)(struct bus_type *bus, char *buf);
  41.     ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
  42. };
  43.  
  44. #define BUS_ATTR(_name, _mode, _show, _store)    \
  45. struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
  46.  
  47. extern int __must_check bus_create_file(struct bus_type *,
  48.                     struct bus_attribute *);
  49. extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
  50.  
  51. struct bus_type {
  52.     const char        *name;
  53.     struct bus_attribute    *bus_attrs;
  54.     struct device_attribute    *dev_attrs;
  55.     struct driver_attribute    *drv_attrs;
  56.  
  57.     int (*match)(struct device *dev, struct device_driver *drv);
  58.     int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
  59.     int (*probe)(struct device *dev);
  60.     int (*remove)(struct device *dev);
  61.     void (*shutdown)(struct device *dev);
  62.  
  63.     int (*suspend)(struct device *dev, pm_message_t state);
  64.     int (*suspend_late)(struct device *dev, pm_message_t state);
  65.     int (*resume_early)(struct device *dev);
  66.     int (*resume)(struct device *dev);
  67.  
  68.     struct pm_ext_ops *pm;
  69.  
  70.     struct bus_type_private *p;
  71. };
  72.  
  73. extern int __must_check bus_register(struct bus_type *bus);
  74. extern void bus_unregister(struct bus_type *bus);
  75.  
  76. extern int __must_check bus_rescan_devices(struct bus_type *bus);
  77.  
  78. /* iterator helpers for buses */
  79.  
  80. int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
  81.              int (*fn)(struct device *dev, void *data));
  82. struct device *bus_find_device(struct bus_type *bus, struct device *start,
  83.                    void *data,
  84.                    int (*match)(struct device *dev, void *data));
  85. struct device *bus_find_device_by_name(struct bus_type *bus,
  86.                        struct device *start,
  87.                        const char *name);
  88.  
  89. int __must_check bus_for_each_drv(struct bus_type *bus,
  90.                   struct device_driver *start, void *data,
  91.                   int (*fn)(struct device_driver *, void *));
  92.  
  93. void bus_sort_breadthfirst(struct bus_type *bus,
  94.                int (*compare)(const struct device *a,
  95.                       const struct device *b));
  96. /*
  97.  * Bus notifiers: Get notified of addition/removal of devices
  98.  * and binding/unbinding of drivers to devices.
  99.  * In the long run, it should be a replacement for the platform
  100.  * notify hooks.
  101.  */
  102. struct notifier_block;
  103.  
  104. extern int bus_register_notifier(struct bus_type *bus,
  105.                  struct notifier_block *nb);
  106. extern int bus_unregister_notifier(struct bus_type *bus,
  107.                    struct notifier_block *nb);
  108.  
  109. /* All 4 notifers below get called with the target struct device *
  110.  * as an argument. Note that those functions are likely to be called
  111.  * with the device semaphore held in the core, so be careful.
  112.  */
  113. #define BUS_NOTIFY_ADD_DEVICE        0x00000001 /* device added */
  114. #define BUS_NOTIFY_DEL_DEVICE        0x00000002 /* device removed */
  115. #define BUS_NOTIFY_BOUND_DRIVER        0x00000003 /* driver bound to device */
  116. #define BUS_NOTIFY_UNBIND_DRIVER    0x00000004 /* driver about to be
  117.                               unbound */
  118.  
  119. extern struct kset *bus_get_kset(struct bus_type *bus);
  120. extern struct klist *bus_get_device_klist(struct bus_type *bus);
  121.  
  122. struct device_driver {
  123.     const char        *name;
  124.     struct bus_type        *bus;
  125.  
  126.     struct module        *owner;
  127.     const char         *mod_name;    /* used for built-in modules */
  128.  
  129.     int (*probe) (struct device *dev);
  130.     int (*remove) (struct device *dev);
  131.     void (*shutdown) (struct device *dev);
  132.     int (*suspend) (struct device *dev, pm_message_t state);
  133.     int (*resume) (struct device *dev);
  134.     struct attribute_group **groups;
  135.  
  136.     struct pm_ops *pm;
  137.  
  138.     struct driver_private *p;
  139. };
  140.  
  141.  
  142. extern int __must_check driver_register(struct device_driver *drv);
  143. extern void driver_unregister(struct device_driver *drv);
  144.  
  145. extern struct device_driver *get_driver(struct device_driver *drv);
  146. extern void put_driver(struct device_driver *drv);
  147. extern struct device_driver *driver_find(const char *name,
  148.                      struct bus_type *bus);
  149. extern int driver_probe_done(void);
  150.  
  151. /* sysfs interface for exporting driver attributes */
  152.  
  153. struct driver_attribute {
  154.     struct attribute attr;
  155.     ssize_t (*show)(struct device_driver *driver, char *buf);
  156.     ssize_t (*store)(struct device_driver *driver, const char *buf,
  157.              size_t count);
  158. };
  159.  
  160. #define DRIVER_ATTR(_name, _mode, _show, _store)    \
  161. struct driver_attribute driver_attr_##_name =        \
  162.     __ATTR(_name, _mode, _show, _store)
  163.  
  164. extern int __must_check driver_create_file(struct device_driver *driver,
  165.                        struct driver_attribute *attr);
  166. extern void driver_remove_file(struct device_driver *driver,
  167.                    struct driver_attribute *attr);
  168.  
  169. extern int __must_check driver_add_kobj(struct device_driver *drv,
  170.                     struct kobject *kobj,
  171.                     const char *fmt, ...);
  172.  
  173. extern int __must_check driver_for_each_device(struct device_driver *drv,
  174.                            struct device *start,
  175.                            void *data,
  176.                            int (*fn)(struct device *dev,
  177.                              void *));
  178. struct device *driver_find_device(struct device_driver *drv,
  179.                   struct device *start, void *data,
  180.                   int (*match)(struct device *dev, void *data));
  181.  
  182. /*
  183.  * device classes
  184.  */
  185. struct class {
  186.     const char        *name;
  187.     struct module        *owner;
  188.  
  189.     struct class_attribute        *class_attrs;
  190.     struct device_attribute        *dev_attrs;
  191.     struct kobject            *dev_kobj;
  192.  
  193.     int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
  194.  
  195.     void (*class_release)(struct class *class);
  196.     void (*dev_release)(struct device *dev);
  197.  
  198.     int (*suspend)(struct device *dev, pm_message_t state);
  199.     int (*resume)(struct device *dev);
  200.  
  201.     struct pm_ops *pm;
  202.     struct class_private *p;
  203. };
  204.  
  205. struct class_dev_iter {
  206.     struct klist_iter        ki;
  207.     const struct device_type    *type;
  208. };
  209.  
  210. extern struct kobject *sysfs_dev_block_kobj;
  211. extern struct kobject *sysfs_dev_char_kobj;
  212. extern int __must_check __class_register(struct class *class,
  213.                      struct lock_class_key *key);
  214. extern void class_unregister(struct class *class);
  215.  
  216. /* This is a #define to keep the compiler from merging different
  217.  * instances of the __key variable */
  218. #define class_register(class)            \
  219. ({                        \
  220.     static struct lock_class_key __key;    \
  221.     __class_register(class, &__key);    \
  222. })
  223.  
  224. extern void class_dev_iter_init(struct class_dev_iter *iter,
  225.                 struct class *class,
  226.                 struct device *start,
  227.                 const struct device_type *type);
  228. extern struct device *class_dev_iter_next(struct class_dev_iter *iter);
  229. extern void class_dev_iter_exit(struct class_dev_iter *iter);
  230.  
  231. extern int class_for_each_device(struct class *class, struct device *start,
  232.                  void *data,
  233.                  int (*fn)(struct device *dev, void *data));
  234. extern struct device *class_find_device(struct class *class,
  235.                     struct device *start, void *data,
  236.                     int (*match)(struct device *, void *));
  237.  
  238. struct class_attribute {
  239.     struct attribute attr;
  240.     ssize_t (*show)(struct class *class, char *buf);
  241.     ssize_t (*store)(struct class *class, const char *buf, size_t count);
  242. };
  243.  
  244. #define CLASS_ATTR(_name, _mode, _show, _store)            \
  245. struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store)
  246.  
  247. extern int __must_check class_create_file(struct class *class,
  248.                       const struct class_attribute *attr);
  249. extern void class_remove_file(struct class *class,
  250.                   const struct class_attribute *attr);
  251.  
  252. struct class_interface {
  253.     struct list_head    node;
  254.     struct class        *class;
  255.  
  256.     int (*add_dev)        (struct device *, struct class_interface *);
  257.     void (*remove_dev)    (struct device *, struct class_interface *);
  258. };
  259.  
  260. extern int __must_check class_interface_register(struct class_interface *);
  261. extern void class_interface_unregister(struct class_interface *);
  262.  
  263. extern struct class * __must_check __class_create(struct module *owner,
  264.                           const char *name,
  265.                           struct lock_class_key *key);
  266. extern void class_destroy(struct class *cls);
  267.  
  268. /* This is a #define to keep the compiler from merging different
  269.  * instances of the __key variable */
  270. #define class_create(owner, name)        \
  271. ({                        \
  272.     static struct lock_class_key __key;    \
  273.     __class_create(owner, name, &__key);    \
  274. })
  275.  
  276. /*
  277.  * The type of device, "struct device" is embedded in. A class
  278.  * or bus can contain devices of different types
  279.  * like "partitions" and "disks", "mouse" and "event".
  280.  * This identifies the device type and carries type-specific
  281.  * information, equivalent to the kobj_type of a kobject.
  282.  * If "name" is specified, the uevent will contain it in
  283.  * the DEVTYPE variable.
  284.  */
  285. struct device_type {
  286.     const char *name;
  287.     struct attribute_group **groups;
  288.     int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
  289.     void (*release)(struct device *dev);
  290.  
  291.     int (*suspend)(struct device *dev, pm_message_t state);
  292.     int (*resume)(struct device *dev);
  293.  
  294.     struct pm_ops *pm;
  295. };
  296.  
  297. /* interface for exporting device attributes */
  298. struct device_attribute {
  299.     struct attribute    attr;
  300.     ssize_t (*show)(struct device *dev, struct device_attribute *attr,
  301.             char *buf);
  302.     ssize_t (*store)(struct device *dev, struct device_attribute *attr,
  303.              const char *buf, size_t count);
  304. };
  305.  
  306. #define DEVICE_ATTR(_name, _mode, _show, _store) \
  307. struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
  308.  
  309. extern int __must_check device_create_file(struct device *device,
  310.                        struct device_attribute *entry);
  311. extern void device_remove_file(struct device *dev,
  312.                    struct device_attribute *attr);
  313. extern int __must_check device_create_bin_file(struct device *dev,
  314.                            struct bin_attribute *attr);
  315. extern void device_remove_bin_file(struct device *dev,
  316.                    struct bin_attribute *attr);
  317. extern int device_schedule_callback_owner(struct device *dev,
  318.         void (*func)(struct device *dev), struct module *owner);
  319.  
  320. /* This is a macro to avoid include problems with THIS_MODULE */
  321. #define device_schedule_callback(dev, func)            \
  322.     device_schedule_callback_owner(dev, func, THIS_MODULE)
  323.  
  324. /* device resource management */
  325. typedef void (*dr_release_t)(struct device *dev, void *res);
  326. typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
  327.  
  328. #ifdef CONFIG_DEBUG_DEVRES
  329. extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
  330.                  const char *name);
  331. #define devres_alloc(release, size, gfp) \
  332.     __devres_alloc(release, size, gfp, #release)
  333. #else
  334. extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp);
  335. #endif
  336. extern void devres_free(void *res);
  337. extern void devres_add(struct device *dev, void *res);
  338. extern void *devres_find(struct device *dev, dr_release_t release,
  339.              dr_match_t match, void *match_data);
  340. extern void *devres_get(struct device *dev, void *new_res,
  341.             dr_match_t match, void *match_data);
  342. extern void *devres_remove(struct device *dev, dr_release_t release,
  343.                dr_match_t match, void *match_data);
  344. extern int devres_destroy(struct device *dev, dr_release_t release,
  345.               dr_match_t match, void *match_data);
  346.  
  347. /* devres group */
  348. extern void * __must_check devres_open_group(struct device *dev, void *id,
  349.                          gfp_t gfp);
  350. extern void devres_close_group(struct device *dev, void *id);
  351. extern void devres_remove_group(struct device *dev, void *id);
  352. extern int devres_release_group(struct device *dev, void *id);
  353.  
  354. /* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */
  355. extern void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp);
  356. extern void devm_kfree(struct device *dev, void *p);
  357.  
  358. struct device_dma_parameters {
  359.     /*
  360.      * a low level driver may set these to teach IOMMU code about
  361.      * sg limitations.
  362.      */
  363.     unsigned int max_segment_size;
  364.     unsigned long segment_boundary_mask;
  365. };
  366.  
  367. struct device {
  368.     struct klist        klist_children;
  369.     struct klist_node    knode_parent;    /* node in sibling list */
  370.     struct klist_node    knode_driver;
  371.     struct klist_node    knode_bus;
  372.     struct device        *parent;
  373.  
  374.     struct kobject kobj;
  375.     char    bus_id[BUS_ID_SIZE];    /* position on parent bus */
  376.     const char        *init_name; /* initial name of the device */
  377.     struct device_type    *type;
  378.     unsigned        uevent_suppress:1;
  379.  
  380.     struct semaphore    sem;    /* semaphore to synchronize calls to
  381.                      * its driver.
  382.                      */
  383.  
  384.     struct bus_type    *bus;        /* type of bus device is on */
  385.     struct device_driver *driver;    /* which driver has allocated this
  386.                        device */
  387.     void        *driver_data;    /* data private to the driver */
  388.     void        *platform_data;    /* Platform specific data, device
  389.                        core doesn't touch it */
  390.     struct dev_pm_info    power;
  391.  
  392. #ifdef CONFIG_NUMA
  393.     int        numa_node;    /* NUMA node this device is close to */
  394. #endif
  395.     u64        *dma_mask;    /* dma mask (if dma'able device) */
  396.     u64        coherent_dma_mask;/* Like dma_mask, but for
  397.                          alloc_coherent mappings as
  398.                          not all hardware supports
  399.                          64 bit addresses for consistent
  400.                          allocations such descriptors. */
  401.  
  402.     struct device_dma_parameters *dma_parms;
  403.  
  404.     struct list_head    dma_pools;    /* dma pools (if dma'ble) */
  405.  
  406.     struct dma_coherent_mem    *dma_mem; /* internal for coherent mem
  407.                          override */
  408.     /* arch specific additions */
  409.     struct dev_archdata    archdata;
  410.  
  411.     spinlock_t        devres_lock;
  412.     struct list_head    devres_head;
  413.  
  414.     struct klist_node    knode_class;
  415.     struct class        *class;
  416.     dev_t            devt;    /* dev_t, creates the sysfs "dev" */
  417.     struct attribute_group    **groups;    /* optional groups */
  418.  
  419.     void    (*release)(struct device *dev);
  420. };
  421.  
  422. /* Get the wakeup routines, which depend on struct device */
  423. #include <linux/pm_wakeup.h>
  424.  
  425. static inline const char *dev_name(const struct device *dev)
  426. {
  427.     /* will be changed into kobject_name(&dev->kobj) in the near future */
  428.     return dev->bus_id;
  429. }
  430.  
  431. extern int dev_set_name(struct device *dev, const char *name, ...)
  432.             __attribute__((format(printf, 2, 3)));
  433.  
  434. #ifdef CONFIG_NUMA
  435. static inline int dev_to_node(struct device *dev)
  436. {
  437.     return dev->numa_node;
  438. }
  439. static inline void set_dev_node(struct device *dev, int node)
  440. {
  441.     dev->numa_node = node;
  442. }
  443. #else
  444. static inline int dev_to_node(struct device *dev)
  445. {
  446.     return -1;
  447. }
  448. static inline void set_dev_node(struct device *dev, int node)
  449. {
  450. }
  451. #endif
  452.  
  453. static inline void *dev_get_drvdata(const struct device *dev)
  454. {
  455.     return dev->driver_data;
  456. }
  457.  
  458. static inline void dev_set_drvdata(struct device *dev, void *data)
  459. {
  460.     dev->driver_data = data;
  461. }
  462.  
  463. static inline int device_is_registered(struct device *dev)
  464. {
  465.     return dev->kobj.state_in_sysfs;
  466. }
  467.  
  468. void driver_init(void);
  469.  
  470. /*
  471.  * High level routines for use by the bus drivers
  472.  */
  473. extern int __must_check device_register(struct device *dev);
  474. extern void device_unregister(struct device *dev);
  475. extern void device_initialize(struct device *dev);
  476. extern int __must_check device_add(struct device *dev);
  477. extern void device_del(struct device *dev);
  478. extern int device_for_each_child(struct device *dev, void *data,
  479.              int (*fn)(struct device *dev, void *data));
  480. extern struct device *device_find_child(struct device *dev, void *data,
  481.                 int (*match)(struct device *dev, void *data));
  482. extern int device_rename(struct device *dev, char *new_name);
  483. extern int device_move(struct device *dev, struct device *new_parent);
  484.  
  485. /*
  486.  * Manual binding of a device to driver. See drivers/base/bus.c
  487.  * for information on use.
  488.  */
  489. extern int __must_check device_bind_driver(struct device *dev);
  490. extern void device_release_driver(struct device *dev);
  491. extern int  __must_check device_attach(struct device *dev);
  492. extern int __must_check driver_attach(struct device_driver *drv);
  493. extern int __must_check device_reprobe(struct device *dev);
  494.  
  495. /*
  496.  * Easy functions for dynamically creating devices on the fly
  497.  */
  498. extern struct device *device_create_vargs(struct class *cls,
  499.                       struct device *parent,
  500.                       dev_t devt,
  501.                       void *drvdata,
  502.                       const char *fmt,
  503.                       va_list vargs);
  504. extern struct device *device_create(struct class *cls, struct device *parent,
  505.                     dev_t devt, void *drvdata,
  506.                     const char *fmt, ...)
  507.                     __attribute__((format(printf, 5, 6)));
  508. extern void device_destroy(struct class *cls, dev_t devt);
  509.  
  510. /*
  511.  * Platform "fixup" functions - allow the platform to have their say
  512.  * about devices and actions that the general device layer doesn't
  513.  * know about.
  514.  */
  515. /* Notify platform of device discovery */
  516. extern int (*platform_notify)(struct device *dev);
  517.  
  518. extern int (*platform_notify_remove)(struct device *dev);
  519.  
  520.  
  521. /**
  522.  * get_device - atomically increment the reference count for the device.
  523.  *
  524.  */
  525. extern struct device *get_device(struct device *dev);
  526. extern void put_device(struct device *dev);
  527.  
  528.  
  529. /* drivers/base/power/shutdown.c */
  530. extern void device_shutdown(void);
  531.  
  532. /* drivers/base/sys.c */
  533. extern void sysdev_shutdown(void);
  534.  
  535. /* debugging and troubleshooting/diagnostic helpers. */
  536. extern const char *dev_driver_string(const struct device *dev);
  537. #define dev_printk(level, dev, format, arg...)    \
  538.     printk(level "%s %s: " format , dev_driver_string(dev) , \
  539.            dev_name(dev) , ## arg)
  540.  
  541. #define dev_emerg(dev, format, arg...)        \
  542.     dev_printk(KERN_EMERG , dev , format , ## arg)
  543. #define dev_alert(dev, format, arg...)        \
  544.     dev_printk(KERN_ALERT , dev , format , ## arg)
  545. #define dev_crit(dev, format, arg...)        \
  546.     dev_printk(KERN_CRIT , dev , format , ## arg)
  547. #define dev_err(dev, format, arg...)        \
  548.     dev_printk(KERN_ERR , dev , format , ## arg)
  549. #define dev_warn(dev, format, arg...)        \
  550.     dev_printk(KERN_WARNING , dev , format , ## arg)
  551. #define dev_notice(dev, format, arg...)        \
  552.     dev_printk(KERN_NOTICE , dev , format , ## arg)
  553. #define dev_info(dev, format, arg...)        \
  554.     dev_printk(KERN_INFO , dev , format , ## arg)
  555.  
  556. #if defined(CONFIG_DYNAMIC_PRINTK_DEBUG)
  557. #define dev_dbg(dev, format, ...) do { \
  558.     dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
  559.     } while (0)
  560. #elif defined(DEBUG)
  561. #define dev_dbg(dev, format, arg...)        \
  562.     dev_printk(KERN_DEBUG , dev , format , ## arg)
  563. #else
  564. #define dev_dbg(dev, format, arg...)        \
  565.     ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
  566. #endif
  567.  
  568. #ifdef VERBOSE_DEBUG
  569. #define dev_vdbg    dev_dbg
  570. #else
  571.  
  572. #define dev_vdbg(dev, format, arg...)        \
  573.     ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
  574. #endif
  575.  
  576. /*
  577.  * dev_WARN() acts like dev_printk(), but with the key difference
  578.  * of using a WARN/WARN_ON to get the message out, including the
  579.  * file/line information and a backtrace.
  580.  */
  581. #define dev_WARN(dev, format, arg...) \
  582.     WARN(1, "Device: %s\n" format, dev_driver_string(dev), ## arg);
  583.  
  584. /* Create alias, so I can be autoloaded. */
  585. #define MODULE_ALIAS_CHARDEV(major,minor) \
  586.     MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
  587. #define MODULE_ALIAS_CHARDEV_MAJOR(major) \
  588.     MODULE_ALIAS("char-major-" __stringify(major) "-*")
  589. #endif /* _DEVICE_H_ */
  590.